package com.zytech.zspider.transformer;// Generated from SpiderDefinition.g4 by ANTLR 4.0

import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.atn.ATN;
import org.antlr.v4.runtime.atn.ATNSimulator;
import org.antlr.v4.runtime.atn.ParserATNSimulator;
import org.antlr.v4.runtime.atn.PredictionContextCache;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.tree.ParseTreeListener;
import org.antlr.v4.runtime.tree.TerminalNode;

import java.util.List;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
class SpiderDefinitionParser extends Parser {
	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		T__1=1, T__0=2, NAME=3, URL=4, METHOD=5, HEADERS=6, PARAMS=7, PARAMS_GENERATOR=8, 
		BODY=9, BODY_GENERATOR=10, SETTINGS=11, TASK=12, ONSTART=13, ONRESULT=14, 
		RETRY_TIMES=15, RETRY_WHEN=16, PROCESS=17, ONFINISH=18, COLLECTS=19, SUBTASKS=20, 
		SUBTASKS_GENERATOR=21, NEXT=22, END=23, STRING=24, INT=25, COMMENT=26, 
		NL=27, WS=28;
	public static final String[] tokenNames = {
		"<INVALID>", "'->'", "','", "'name'", "'url'", "'method'", "'headers'", 
		"'params'", "'params_generator'", "'body'", "'body_generator'", "'settings'", 
		"'taskdef'", "'onstart'", "'onresult'", "'retry_times'", "'retry_when'", 
		"'process'", "'onfinish'", "'collects'", "'subtasks'", "'subtasks_generator'", 
		"'next'", "'end'", "STRING", "INT", "COMMENT", "NL", "WS"
	};
	public static final int
		RULE_transform = 0, RULE_nameDef = 1, RULE_urlDef = 2, RULE_methodDef = 3, 
		RULE_headersDef = 4, RULE_paramsDef = 5, RULE_paramsGeneratorDef = 6, 
		RULE_bodyDef = 7, RULE_bodyGeneratorDef = 8, RULE_settingsDef = 9, RULE_taskDef = 10, 
		RULE_onstartDef = 11, RULE_onresultDef = 12, RULE_retryDef = 13, RULE_retryTimesDef = 14, 
		RULE_processDef = 15, RULE_onfinishDef = 16, RULE_collectsDef = 17, RULE_subtasksDef = 18, 
		RULE_subtasksGeneratorDef = 19, RULE_nextDef = 20, RULE_pair = 21;
	public static final String[] ruleNames = {
		"transform", "nameDef", "urlDef", "methodDef", "headersDef", "paramsDef", 
		"paramsGeneratorDef", "bodyDef", "bodyGeneratorDef", "settingsDef", "taskDef", 
		"onstartDef", "onresultDef", "retryDef", "retryTimesDef", "processDef", 
		"onfinishDef", "collectsDef", "subtasksDef", "subtasksGeneratorDef", "nextDef", 
		"pair"
	};

	@Override
	public String getGrammarFileName() { return "SpiderDefinition.g4"; }

	@Override
	public String[] getTokenNames() { return tokenNames; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public ATN getATN() { return _ATN; }

	public SpiderDefinitionParser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}
	public static class TransformContext extends ParserRuleContext {
		public List<SettingsDefContext> settingsDef() {
			return getRuleContexts(SettingsDefContext.class);
		}
		public ParamsGeneratorDefContext paramsGeneratorDef(int i) {
			return getRuleContext(ParamsGeneratorDefContext.class,i);
		}
		public List<ParamsDefContext> paramsDef() {
			return getRuleContexts(ParamsDefContext.class);
		}
		public List<HeadersDefContext> headersDef() {
			return getRuleContexts(HeadersDefContext.class);
		}
		public BodyGeneratorDefContext bodyGeneratorDef(int i) {
			return getRuleContext(BodyGeneratorDefContext.class,i);
		}
		public SettingsDefContext settingsDef(int i) {
			return getRuleContext(SettingsDefContext.class,i);
		}
		public List<TaskDefContext> taskDef() {
			return getRuleContexts(TaskDefContext.class);
		}
		public NameDefContext nameDef() {
			return getRuleContext(NameDefContext.class,0);
		}
		public TaskDefContext taskDef(int i) {
			return getRuleContext(TaskDefContext.class,i);
		}
		public List<BodyGeneratorDefContext> bodyGeneratorDef() {
			return getRuleContexts(BodyGeneratorDefContext.class);
		}
		public HeadersDefContext headersDef(int i) {
			return getRuleContext(HeadersDefContext.class,i);
		}
		public ParamsDefContext paramsDef(int i) {
			return getRuleContext(ParamsDefContext.class,i);
		}
		public List<ParamsGeneratorDefContext> paramsGeneratorDef() {
			return getRuleContexts(ParamsGeneratorDefContext.class);
		}
		public TransformContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_transform; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterTransform(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitTransform(this);
		}
	}

	public final TransformContext transform() throws RecognitionException {
		TransformContext _localctx = new TransformContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_transform);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(44); nameDef();
			setState(52);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << HEADERS) | (1L << PARAMS) | (1L << PARAMS_GENERATOR) | (1L << BODY_GENERATOR) | (1L << SETTINGS))) != 0)) {
				{
				setState(50);
				switch (_input.LA(1)) {
				case HEADERS:
					{
					setState(45); headersDef();
					}
					break;
				case PARAMS:
					{
					setState(46); paramsDef();
					}
					break;
				case PARAMS_GENERATOR:
					{
					setState(47); paramsGeneratorDef();
					}
					break;
				case BODY_GENERATOR:
					{
					setState(48); bodyGeneratorDef();
					}
					break;
				case SETTINGS:
					{
					setState(49); settingsDef();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				setState(54);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(56); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(55); taskDef();
				}
				}
				setState(58); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( _la==TASK );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NameDefContext extends ParserRuleContext {
		public TerminalNode NAME() { return getToken(SpiderDefinitionParser.NAME, 0); }
		public TerminalNode STRING() { return getToken(SpiderDefinitionParser.STRING, 0); }
		public NameDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nameDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterNameDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitNameDef(this);
		}
	}

	public final NameDefContext nameDef() throws RecognitionException {
		NameDefContext _localctx = new NameDefContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_nameDef);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(60); match(NAME);
			setState(61); match(1);
			setState(62); match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class UrlDefContext extends ParserRuleContext {
		public TerminalNode URL() { return getToken(SpiderDefinitionParser.URL, 0); }
		public TerminalNode STRING() { return getToken(SpiderDefinitionParser.STRING, 0); }
		public UrlDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_urlDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterUrlDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitUrlDef(this);
		}
	}

	public final UrlDefContext urlDef() throws RecognitionException {
		UrlDefContext _localctx = new UrlDefContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_urlDef);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(64); match(URL);
			setState(65); match(1);
			setState(66); match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class MethodDefContext extends ParserRuleContext {
		public TerminalNode METHOD() { return getToken(SpiderDefinitionParser.METHOD, 0); }
		public TerminalNode STRING() { return getToken(SpiderDefinitionParser.STRING, 0); }
		public MethodDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_methodDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterMethodDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitMethodDef(this);
		}
	}

	public final MethodDefContext methodDef() throws RecognitionException {
		MethodDefContext _localctx = new MethodDefContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_methodDef);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(68); match(METHOD);
			setState(69); match(1);
			setState(70); match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class HeadersDefContext extends ParserRuleContext {
		public List<PairContext> pair() {
			return getRuleContexts(PairContext.class);
		}
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public PairContext pair(int i) {
			return getRuleContext(PairContext.class,i);
		}
		public TerminalNode HEADERS() { return getToken(SpiderDefinitionParser.HEADERS, 0); }
		public HeadersDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_headersDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterHeadersDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitHeadersDef(this);
		}
	}

	public final HeadersDefContext headersDef() throws RecognitionException {
		HeadersDefContext _localctx = new HeadersDefContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_headersDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(72); match(HEADERS);
			setState(76);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==STRING) {
				{
				{
				setState(73); pair();
				}
				}
				setState(78);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(79); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ParamsDefContext extends ParserRuleContext {
		public List<PairContext> pair() {
			return getRuleContexts(PairContext.class);
		}
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public PairContext pair(int i) {
			return getRuleContext(PairContext.class,i);
		}
		public TerminalNode PARAMS() { return getToken(SpiderDefinitionParser.PARAMS, 0); }
		public ParamsDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_paramsDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterParamsDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitParamsDef(this);
		}
	}

	public final ParamsDefContext paramsDef() throws RecognitionException {
		ParamsDefContext _localctx = new ParamsDefContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_paramsDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(81); match(PARAMS);
			setState(85);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==STRING) {
				{
				{
				setState(82); pair();
				}
				}
				setState(87);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(88); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ParamsGeneratorDefContext extends ParserRuleContext {
		public TerminalNode PARAMS_GENERATOR() { return getToken(SpiderDefinitionParser.PARAMS_GENERATOR, 0); }
		public List<PairContext> pair() {
			return getRuleContexts(PairContext.class);
		}
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public PairContext pair(int i) {
			return getRuleContext(PairContext.class,i);
		}
		public ParamsGeneratorDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_paramsGeneratorDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterParamsGeneratorDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitParamsGeneratorDef(this);
		}
	}

	public final ParamsGeneratorDefContext paramsGeneratorDef() throws RecognitionException {
		ParamsGeneratorDefContext _localctx = new ParamsGeneratorDefContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_paramsGeneratorDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(90); match(PARAMS_GENERATOR);
			setState(94);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==STRING) {
				{
				{
				setState(91); pair();
				}
				}
				setState(96);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(97); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BodyDefContext extends ParserRuleContext {
		public TerminalNode BODY() { return getToken(SpiderDefinitionParser.BODY, 0); }
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public TerminalNode STRING() { return getToken(SpiderDefinitionParser.STRING, 0); }
		public BodyDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bodyDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterBodyDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitBodyDef(this);
		}
	}

	public final BodyDefContext bodyDef() throws RecognitionException {
		BodyDefContext _localctx = new BodyDefContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_bodyDef);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(99); match(BODY);
			setState(100); match(STRING);
			setState(101); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class BodyGeneratorDefContext extends ParserRuleContext {
		public TerminalNode BODY_GENERATOR() { return getToken(SpiderDefinitionParser.BODY_GENERATOR, 0); }
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public TerminalNode STRING() { return getToken(SpiderDefinitionParser.STRING, 0); }
		public BodyGeneratorDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_bodyGeneratorDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterBodyGeneratorDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitBodyGeneratorDef(this);
		}
	}

	public final BodyGeneratorDefContext bodyGeneratorDef() throws RecognitionException {
		BodyGeneratorDefContext _localctx = new BodyGeneratorDefContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_bodyGeneratorDef);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(103); match(BODY_GENERATOR);
			setState(104); match(STRING);
			setState(105); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SettingsDefContext extends ParserRuleContext {
		public List<PairContext> pair() {
			return getRuleContexts(PairContext.class);
		}
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public TerminalNode SETTINGS() { return getToken(SpiderDefinitionParser.SETTINGS, 0); }
		public PairContext pair(int i) {
			return getRuleContext(PairContext.class,i);
		}
		public SettingsDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_settingsDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterSettingsDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitSettingsDef(this);
		}
	}

	public final SettingsDefContext settingsDef() throws RecognitionException {
		SettingsDefContext _localctx = new SettingsDefContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_settingsDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(107); match(SETTINGS);
			setState(111);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==STRING) {
				{
				{
				setState(108); pair();
				}
				}
				setState(113);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(114); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TaskDefContext extends ParserRuleContext {
		public List<OnresultDefContext> onresultDef() {
			return getRuleContexts(OnresultDefContext.class);
		}
		public MethodDefContext methodDef() {
			return getRuleContext(MethodDefContext.class,0);
		}
		public CollectsDefContext collectsDef(int i) {
			return getRuleContext(CollectsDefContext.class,i);
		}
		public List<SubtasksGeneratorDefContext> subtasksGeneratorDef() {
			return getRuleContexts(SubtasksGeneratorDefContext.class);
		}
		public List<ParamsDefContext> paramsDef() {
			return getRuleContexts(ParamsDefContext.class);
		}
		public OnresultDefContext onresultDef(int i) {
			return getRuleContext(OnresultDefContext.class,i);
		}
		public List<HeadersDefContext> headersDef() {
			return getRuleContexts(HeadersDefContext.class);
		}
		public SubtasksDefContext subtasksDef(int i) {
			return getRuleContext(SubtasksDefContext.class,i);
		}
		public TerminalNode TASK() { return getToken(SpiderDefinitionParser.TASK, 0); }
		public List<CollectsDefContext> collectsDef() {
			return getRuleContexts(CollectsDefContext.class);
		}
		public ParamsDefContext paramsDef(int i) {
			return getRuleContext(ParamsDefContext.class,i);
		}
		public List<BodyDefContext> bodyDef() {
			return getRuleContexts(BodyDefContext.class);
		}
		public List<OnfinishDefContext> onfinishDef() {
			return getRuleContexts(OnfinishDefContext.class);
		}
		public List<SettingsDefContext> settingsDef() {
			return getRuleContexts(SettingsDefContext.class);
		}
		public SettingsDefContext settingsDef(int i) {
			return getRuleContext(SettingsDefContext.class,i);
		}
		public BodyDefContext bodyDef(int i) {
			return getRuleContext(BodyDefContext.class,i);
		}
		public OnstartDefContext onstartDef(int i) {
			return getRuleContext(OnstartDefContext.class,i);
		}
		public NameDefContext nameDef() {
			return getRuleContext(NameDefContext.class,0);
		}
		public HeadersDefContext headersDef(int i) {
			return getRuleContext(HeadersDefContext.class,i);
		}
		public List<OnstartDefContext> onstartDef() {
			return getRuleContexts(OnstartDefContext.class);
		}
		public OnfinishDefContext onfinishDef(int i) {
			return getRuleContext(OnfinishDefContext.class,i);
		}
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public SubtasksGeneratorDefContext subtasksGeneratorDef(int i) {
			return getRuleContext(SubtasksGeneratorDefContext.class,i);
		}
		public List<SubtasksDefContext> subtasksDef() {
			return getRuleContexts(SubtasksDefContext.class);
		}
		public UrlDefContext urlDef() {
			return getRuleContext(UrlDefContext.class,0);
		}
		public TaskDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_taskDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterTaskDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitTaskDef(this);
		}
	}

	public final TaskDefContext taskDef() throws RecognitionException {
		TaskDefContext _localctx = new TaskDefContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_taskDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(116); match(TASK);
			setState(117); nameDef();
			setState(118); urlDef();
			setState(119); methodDef();
			setState(131);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << HEADERS) | (1L << PARAMS) | (1L << BODY) | (1L << SETTINGS) | (1L << ONSTART) | (1L << ONRESULT) | (1L << ONFINISH) | (1L << COLLECTS) | (1L << SUBTASKS))) != 0)) {
				{
				setState(129);
				switch (_input.LA(1)) {
				case PARAMS:
					{
					setState(120); paramsDef();
					}
					break;
				case HEADERS:
					{
					setState(121); headersDef();
					}
					break;
				case SETTINGS:
					{
					setState(122); settingsDef();
					}
					break;
				case BODY:
					{
					setState(123); bodyDef();
					}
					break;
				case ONSTART:
					{
					setState(124); onstartDef();
					}
					break;
				case ONFINISH:
					{
					setState(125); onfinishDef();
					}
					break;
				case ONRESULT:
					{
					setState(126); onresultDef();
					}
					break;
				case COLLECTS:
					{
					setState(127); collectsDef();
					}
					break;
				case SUBTASKS:
					{
					setState(128); subtasksDef();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				setState(133);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(137);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==SUBTASKS_GENERATOR) {
				{
				{
				setState(134); subtasksGeneratorDef();
				}
				}
				setState(139);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(140); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OnstartDefContext extends ParserRuleContext {
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public TerminalNode ONSTART() { return getToken(SpiderDefinitionParser.ONSTART, 0); }
		public TerminalNode STRING() { return getToken(SpiderDefinitionParser.STRING, 0); }
		public OnstartDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_onstartDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterOnstartDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitOnstartDef(this);
		}
	}

	public final OnstartDefContext onstartDef() throws RecognitionException {
		OnstartDefContext _localctx = new OnstartDefContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_onstartDef);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(142); match(ONSTART);
			setState(143); match(STRING);
			setState(144); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OnresultDefContext extends ParserRuleContext {
		public RetryTimesDefContext retryTimesDef() {
			return getRuleContext(RetryTimesDefContext.class,0);
		}
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public TerminalNode ONRESULT() { return getToken(SpiderDefinitionParser.ONRESULT, 0); }
		public RetryDefContext retryDef() {
			return getRuleContext(RetryDefContext.class,0);
		}
		public ProcessDefContext processDef() {
			return getRuleContext(ProcessDefContext.class,0);
		}
		public OnresultDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_onresultDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterOnresultDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitOnresultDef(this);
		}
	}

	public final OnresultDefContext onresultDef() throws RecognitionException {
		OnresultDefContext _localctx = new OnresultDefContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_onresultDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(146); match(ONRESULT);
			setState(154);
			switch (_input.LA(1)) {
			case RETRY_WHEN:
				{
				{
				setState(147); retryDef();
				setState(149);
				_la = _input.LA(1);
				if (_la==RETRY_TIMES) {
					{
					setState(148); retryTimesDef();
					}
				}

				setState(151); processDef();
				}
				}
				break;
			case PROCESS:
				{
				setState(153); processDef();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(156); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RetryDefContext extends ParserRuleContext {
		public TerminalNode RETRY_WHEN() { return getToken(SpiderDefinitionParser.RETRY_WHEN, 0); }
		public TerminalNode STRING() { return getToken(SpiderDefinitionParser.STRING, 0); }
		public RetryDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_retryDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterRetryDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitRetryDef(this);
		}
	}

	public final RetryDefContext retryDef() throws RecognitionException {
		RetryDefContext _localctx = new RetryDefContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_retryDef);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(158); match(RETRY_WHEN);
			setState(159); match(1);
			setState(160); match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RetryTimesDefContext extends ParserRuleContext {
		public TerminalNode RETRY_TIMES() { return getToken(SpiderDefinitionParser.RETRY_TIMES, 0); }
		public TerminalNode INT() { return getToken(SpiderDefinitionParser.INT, 0); }
		public RetryTimesDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_retryTimesDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterRetryTimesDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitRetryTimesDef(this);
		}
	}

	public final RetryTimesDefContext retryTimesDef() throws RecognitionException {
		RetryTimesDefContext _localctx = new RetryTimesDefContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_retryTimesDef);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(162); match(RETRY_TIMES);
			setState(163); match(1);
			setState(164); match(INT);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ProcessDefContext extends ParserRuleContext {
		public TerminalNode PROCESS() { return getToken(SpiderDefinitionParser.PROCESS, 0); }
		public TerminalNode STRING() { return getToken(SpiderDefinitionParser.STRING, 0); }
		public ProcessDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_processDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterProcessDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitProcessDef(this);
		}
	}

	public final ProcessDefContext processDef() throws RecognitionException {
		ProcessDefContext _localctx = new ProcessDefContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_processDef);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(166); match(PROCESS);
			setState(167); match(1);
			setState(168); match(STRING);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class OnfinishDefContext extends ParserRuleContext {
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public TerminalNode STRING() { return getToken(SpiderDefinitionParser.STRING, 0); }
		public TerminalNode ONFINISH() { return getToken(SpiderDefinitionParser.ONFINISH, 0); }
		public OnfinishDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_onfinishDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterOnfinishDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitOnfinishDef(this);
		}
	}

	public final OnfinishDefContext onfinishDef() throws RecognitionException {
		OnfinishDefContext _localctx = new OnfinishDefContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_onfinishDef);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(170); match(ONFINISH);
			setState(171); match(STRING);
			setState(172); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class CollectsDefContext extends ParserRuleContext {
		public TerminalNode COLLECTS() { return getToken(SpiderDefinitionParser.COLLECTS, 0); }
		public List<PairContext> pair() {
			return getRuleContexts(PairContext.class);
		}
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public PairContext pair(int i) {
			return getRuleContext(PairContext.class,i);
		}
		public CollectsDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_collectsDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterCollectsDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitCollectsDef(this);
		}
	}

	public final CollectsDefContext collectsDef() throws RecognitionException {
		CollectsDefContext _localctx = new CollectsDefContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_collectsDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(174); match(COLLECTS);
			setState(178);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==STRING) {
				{
				{
				setState(175); pair();
				}
				}
				setState(180);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(181); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SubtasksDefContext extends ParserRuleContext {
		public TerminalNode STRING(int i) {
			return getToken(SpiderDefinitionParser.STRING, i);
		}
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public TerminalNode SUBTASKS() { return getToken(SpiderDefinitionParser.SUBTASKS, 0); }
		public List<TerminalNode> STRING() { return getTokens(SpiderDefinitionParser.STRING); }
		public SubtasksDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subtasksDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterSubtasksDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitSubtasksDef(this);
		}
	}

	public final SubtasksDefContext subtasksDef() throws RecognitionException {
		SubtasksDefContext _localctx = new SubtasksDefContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_subtasksDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(183); match(SUBTASKS);
			setState(184); match(STRING);
			setState(189);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==2) {
				{
				{
				setState(185); match(2);
				setState(186); match(STRING);
				}
				}
				setState(191);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(192); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SubtasksGeneratorDefContext extends ParserRuleContext {
		public List<OnresultDefContext> onresultDef() {
			return getRuleContexts(OnresultDefContext.class);
		}
		public CollectsDefContext collectsDef(int i) {
			return getRuleContext(CollectsDefContext.class,i);
		}
		public TerminalNode SUBTASKS_GENERATOR() { return getToken(SpiderDefinitionParser.SUBTASKS_GENERATOR, 0); }
		public OnresultDefContext onresultDef(int i) {
			return getRuleContext(OnresultDefContext.class,i);
		}
		public NextDefContext nextDef() {
			return getRuleContext(NextDefContext.class,0);
		}
		public OnstartDefContext onstartDef(int i) {
			return getRuleContext(OnstartDefContext.class,i);
		}
		public NameDefContext nameDef() {
			return getRuleContext(NameDefContext.class,0);
		}
		public List<OnstartDefContext> onstartDef() {
			return getRuleContexts(OnstartDefContext.class);
		}
		public List<CollectsDefContext> collectsDef() {
			return getRuleContexts(CollectsDefContext.class);
		}
		public OnfinishDefContext onfinishDef(int i) {
			return getRuleContext(OnfinishDefContext.class,i);
		}
		public TerminalNode END() { return getToken(SpiderDefinitionParser.END, 0); }
		public TerminalNode STRING() { return getToken(SpiderDefinitionParser.STRING, 0); }
		public List<OnfinishDefContext> onfinishDef() {
			return getRuleContexts(OnfinishDefContext.class);
		}
		public SubtasksGeneratorDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_subtasksGeneratorDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterSubtasksGeneratorDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitSubtasksGeneratorDef(this);
		}
	}

	public final SubtasksGeneratorDefContext subtasksGeneratorDef() throws RecognitionException {
		SubtasksGeneratorDefContext _localctx = new SubtasksGeneratorDefContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_subtasksGeneratorDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(194); match(SUBTASKS_GENERATOR);
			setState(195); nameDef();
			setState(197);
			_la = _input.LA(1);
			if (_la==NEXT) {
				{
				setState(196); nextDef();
				}
			}

			setState(205);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ONSTART) | (1L << ONRESULT) | (1L << ONFINISH) | (1L << COLLECTS))) != 0)) {
				{
				setState(203);
				switch (_input.LA(1)) {
				case ONSTART:
					{
					setState(199); onstartDef();
					}
					break;
				case ONRESULT:
					{
					setState(200); onresultDef();
					}
					break;
				case ONFINISH:
					{
					setState(201); onfinishDef();
					}
					break;
				case COLLECTS:
					{
					setState(202); collectsDef();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				setState(207);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			setState(208); match(STRING);
			setState(209); match(END);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NextDefContext extends ParserRuleContext {
		public TerminalNode NEXT() { return getToken(SpiderDefinitionParser.NEXT, 0); }
		public TerminalNode STRING(int i) {
			return getToken(SpiderDefinitionParser.STRING, i);
		}
		public List<TerminalNode> STRING() { return getTokens(SpiderDefinitionParser.STRING); }
		public NextDefContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_nextDef; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterNextDef(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitNextDef(this);
		}
	}

	public final NextDefContext nextDef() throws RecognitionException {
		NextDefContext _localctx = new NextDefContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_nextDef);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(211); match(NEXT);
			setState(212); match(1);
			setState(213); match(STRING);
			setState(218);
			_errHandler.sync(this);
			_la = _input.LA(1);
			while (_la==2) {
				{
				{
				setState(214); match(2);
				setState(215); match(STRING);
				}
				}
				setState(220);
				_errHandler.sync(this);
				_la = _input.LA(1);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PairContext extends ParserRuleContext {
		public TerminalNode INT() { return getToken(SpiderDefinitionParser.INT, 0); }
		public TerminalNode STRING(int i) {
			return getToken(SpiderDefinitionParser.STRING, i);
		}
		public List<TerminalNode> STRING() { return getTokens(SpiderDefinitionParser.STRING); }
		public PairContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_pair; }
		@Override
		public void enterRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).enterPair(this);
		}
		@Override
		public void exitRule(ParseTreeListener listener) {
			if ( listener instanceof SpiderDefinitionListener) ((SpiderDefinitionListener)listener).exitPair(this);
		}
	}

	public final PairContext pair() throws RecognitionException {
		PairContext _localctx = new PairContext(_ctx, getState());
		enterRule(_localctx, 42, RULE_pair);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(221); match(STRING);
			setState(222); match(1);
			setState(223);
			_la = _input.LA(1);
			if ( !(_la==STRING || _la==INT) ) {
			_errHandler.recoverInline(this);
			}
			consume();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\2\3\36\u00e4\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b"+
		"\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t"+
		"\20\4\21\t\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t"+
		"\27\3\2\3\2\3\2\3\2\3\2\3\2\7\2\65\n\2\f\2\16\28\13\2\3\2\6\2;\n\2\r\2"+
		"\16\2<\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\6\3\6\7\6M\n"+
		"\6\f\6\16\6P\13\6\3\6\3\6\3\7\3\7\7\7V\n\7\f\7\16\7Y\13\7\3\7\3\7\3\b"+
		"\3\b\7\b_\n\b\f\b\16\bb\13\b\3\b\3\b\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3"+
		"\13\3\13\7\13p\n\13\f\13\16\13s\13\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3"+
		"\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\7\f\u0084\n\f\f\f\16\f\u0087\13\f\3\f\7"+
		"\f\u008a\n\f\f\f\16\f\u008d\13\f\3\f\3\f\3\r\3\r\3\r\3\r\3\16\3\16\3\16"+
		"\5\16\u0098\n\16\3\16\3\16\3\16\5\16\u009d\n\16\3\16\3\16\3\17\3\17\3"+
		"\17\3\17\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3"+
		"\23\3\23\7\23\u00b3\n\23\f\23\16\23\u00b6\13\23\3\23\3\23\3\24\3\24\3"+
		"\24\3\24\7\24\u00be\n\24\f\24\16\24\u00c1\13\24\3\24\3\24\3\25\3\25\3"+
		"\25\5\25\u00c8\n\25\3\25\3\25\3\25\3\25\7\25\u00ce\n\25\f\25\16\25\u00d1"+
		"\13\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\7\26\u00db\n\26\f\26\16"+
		"\26\u00de\13\26\3\27\3\27\3\27\3\27\3\27\2\30\2\4\6\b\n\f\16\20\22\24"+
		"\26\30\32\34\36 \"$&(*,\2\3\3\32\33\u00eb\2.\3\2\2\2\4>\3\2\2\2\6B\3\2"+
		"\2\2\bF\3\2\2\2\nJ\3\2\2\2\fS\3\2\2\2\16\\\3\2\2\2\20e\3\2\2\2\22i\3\2"+
		"\2\2\24m\3\2\2\2\26v\3\2\2\2\30\u0090\3\2\2\2\32\u0094\3\2\2\2\34\u00a0"+
		"\3\2\2\2\36\u00a4\3\2\2\2 \u00a8\3\2\2\2\"\u00ac\3\2\2\2$\u00b0\3\2\2"+
		"\2&\u00b9\3\2\2\2(\u00c4\3\2\2\2*\u00d5\3\2\2\2,\u00df\3\2\2\2.\66\5\4"+
		"\3\2/\65\5\n\6\2\60\65\5\f\7\2\61\65\5\16\b\2\62\65\5\22\n\2\63\65\5\24"+
		"\13\2\64/\3\2\2\2\64\60\3\2\2\2\64\61\3\2\2\2\64\62\3\2\2\2\64\63\3\2"+
		"\2\2\658\3\2\2\2\66\64\3\2\2\2\66\67\3\2\2\2\67:\3\2\2\28\66\3\2\2\29"+
		";\5\26\f\2:9\3\2\2\2;<\3\2\2\2<:\3\2\2\2<=\3\2\2\2=\3\3\2\2\2>?\7\5\2"+
		"\2?@\7\3\2\2@A\7\32\2\2A\5\3\2\2\2BC\7\6\2\2CD\7\3\2\2DE\7\32\2\2E\7\3"+
		"\2\2\2FG\7\7\2\2GH\7\3\2\2HI\7\32\2\2I\t\3\2\2\2JN\7\b\2\2KM\5,\27\2L"+
		"K\3\2\2\2MP\3\2\2\2NL\3\2\2\2NO\3\2\2\2OQ\3\2\2\2PN\3\2\2\2QR\7\31\2\2"+
		"R\13\3\2\2\2SW\7\t\2\2TV\5,\27\2UT\3\2\2\2VY\3\2\2\2WU\3\2\2\2WX\3\2\2"+
		"\2XZ\3\2\2\2YW\3\2\2\2Z[\7\31\2\2[\r\3\2\2\2\\`\7\n\2\2]_\5,\27\2^]\3"+
		"\2\2\2_b\3\2\2\2`^\3\2\2\2`a\3\2\2\2ac\3\2\2\2b`\3\2\2\2cd\7\31\2\2d\17"+
		"\3\2\2\2ef\7\13\2\2fg\7\32\2\2gh\7\31\2\2h\21\3\2\2\2ij\7\f\2\2jk\7\32"+
		"\2\2kl\7\31\2\2l\23\3\2\2\2mq\7\r\2\2np\5,\27\2on\3\2\2\2ps\3\2\2\2qo"+
		"\3\2\2\2qr\3\2\2\2rt\3\2\2\2sq\3\2\2\2tu\7\31\2\2u\25\3\2\2\2vw\7\16\2"+
		"\2wx\5\4\3\2xy\5\6\4\2y\u0085\5\b\5\2z\u0084\5\f\7\2{\u0084\5\n\6\2|\u0084"+
		"\5\24\13\2}\u0084\5\20\t\2~\u0084\5\30\r\2\177\u0084\5\"\22\2\u0080\u0084"+
		"\5\32\16\2\u0081\u0084\5$\23\2\u0082\u0084\5&\24\2\u0083z\3\2\2\2\u0083"+
		"{\3\2\2\2\u0083|\3\2\2\2\u0083}\3\2\2\2\u0083~\3\2\2\2\u0083\177\3\2\2"+
		"\2\u0083\u0080\3\2\2\2\u0083\u0081\3\2\2\2\u0083\u0082\3\2\2\2\u0084\u0087"+
		"\3\2\2\2\u0085\u0083\3\2\2\2\u0085\u0086\3\2\2\2\u0086\u008b\3\2\2\2\u0087"+
		"\u0085\3\2\2\2\u0088\u008a\5(\25\2\u0089\u0088\3\2\2\2\u008a\u008d\3\2"+
		"\2\2\u008b\u0089\3\2\2\2\u008b\u008c\3\2\2\2\u008c\u008e\3\2\2\2\u008d"+
		"\u008b\3\2\2\2\u008e\u008f\7\31\2\2\u008f\27\3\2\2\2\u0090\u0091\7\17"+
		"\2\2\u0091\u0092\7\32\2\2\u0092\u0093\7\31\2\2\u0093\31\3\2\2\2\u0094"+
		"\u009c\7\20\2\2\u0095\u0097\5\34\17\2\u0096\u0098\5\36\20\2\u0097\u0096"+
		"\3\2\2\2\u0097\u0098\3\2\2\2\u0098\u0099\3\2\2\2\u0099\u009a\5 \21\2\u009a"+
		"\u009d\3\2\2\2\u009b\u009d\5 \21\2\u009c\u0095\3\2\2\2\u009c\u009b\3\2"+
		"\2\2\u009d\u009e\3\2\2\2\u009e\u009f\7\31\2\2\u009f\33\3\2\2\2\u00a0\u00a1"+
		"\7\22\2\2\u00a1\u00a2\7\3\2\2\u00a2\u00a3\7\32\2\2\u00a3\35\3\2\2\2\u00a4"+
		"\u00a5\7\21\2\2\u00a5\u00a6\7\3\2\2\u00a6\u00a7\7\33\2\2\u00a7\37\3\2"+
		"\2\2\u00a8\u00a9\7\23\2\2\u00a9\u00aa\7\3\2\2\u00aa\u00ab\7\32\2\2\u00ab"+
		"!\3\2\2\2\u00ac\u00ad\7\24\2\2\u00ad\u00ae\7\32\2\2\u00ae\u00af\7\31\2"+
		"\2\u00af#\3\2\2\2\u00b0\u00b4\7\25\2\2\u00b1\u00b3\5,\27\2\u00b2\u00b1"+
		"\3\2\2\2\u00b3\u00b6\3\2\2\2\u00b4\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5"+
		"\u00b7\3\2\2\2\u00b6\u00b4\3\2\2\2\u00b7\u00b8\7\31\2\2\u00b8%\3\2\2\2"+
		"\u00b9\u00ba\7\26\2\2\u00ba\u00bf\7\32\2\2\u00bb\u00bc\7\4\2\2\u00bc\u00be"+
		"\7\32\2\2\u00bd\u00bb\3\2\2\2\u00be\u00c1\3\2\2\2\u00bf\u00bd\3\2\2\2"+
		"\u00bf\u00c0\3\2\2\2\u00c0\u00c2\3\2\2\2\u00c1\u00bf\3\2\2\2\u00c2\u00c3"+
		"\7\31\2\2\u00c3\'\3\2\2\2\u00c4\u00c5\7\27\2\2\u00c5\u00c7\5\4\3\2\u00c6"+
		"\u00c8\5*\26\2\u00c7\u00c6\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\u00cf\3\2"+
		"\2\2\u00c9\u00ce\5\30\r\2\u00ca\u00ce\5\32\16\2\u00cb\u00ce\5\"\22\2\u00cc"+
		"\u00ce\5$\23\2\u00cd\u00c9\3\2\2\2\u00cd\u00ca\3\2\2\2\u00cd\u00cb\3\2"+
		"\2\2\u00cd\u00cc\3\2\2\2\u00ce\u00d1\3\2\2\2\u00cf\u00cd\3\2\2\2\u00cf"+
		"\u00d0\3\2\2\2\u00d0\u00d2\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d2\u00d3\7\32"+
		"\2\2\u00d3\u00d4\7\31\2\2\u00d4)\3\2\2\2\u00d5\u00d6\7\30\2\2\u00d6\u00d7"+
		"\7\3\2\2\u00d7\u00dc\7\32\2\2\u00d8\u00d9\7\4\2\2\u00d9\u00db\7\32\2\2"+
		"\u00da\u00d8\3\2\2\2\u00db\u00de\3\2\2\2\u00dc\u00da\3\2\2\2\u00dc\u00dd"+
		"\3\2\2\2\u00dd+\3\2\2\2\u00de\u00dc\3\2\2\2\u00df\u00e0\7\32\2\2\u00e0"+
		"\u00e1\7\3\2\2\u00e1\u00e2\t\2\2\2\u00e2-\3\2\2\2\24\64\66<NW`q\u0083"+
		"\u0085\u008b\u0097\u009c\u00b4\u00bf\u00c7\u00cd\u00cf\u00dc";
	public static final ATN _ATN =
		ATNSimulator.deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
	}
}